package cn.zhentao.service;

import cn.zhentao.entity.GameSession;
import cn.zhentao.entity.AiSession;
import cn.zhentao.util.DashScopeAiUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * AI对话服务
 * 对接小程序AI功能模块
 */
@Slf4j
@Service
public class AiConversationService {

    @Autowired
    private DashScopeAiUtil dashScopeAiUtil;

    @Autowired
    private GameSessionService gameSessionService;

    @Autowired
    private AiSessionService aiSessionService;

    // 保存最后一次AI响应，用于错误显示
    private String lastAiResponse;



    // 用户会话缓存
    private final Map<Long, Map<String, Object>> userSessions = new ConcurrentHashMap<>();

    /**
     * 知识问答 - AI百科全书（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse knowledgeQA(Long userId, String question) {
        log.info("知识问答请求 - 用户ID: {}, 问题: {}", userId, question);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.KNOWLEDGE_QA);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildKnowledgePromptWithMemory(question, aiSession);

        // 使用AI会话ID进行对话
        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), question, response.getText(), null);

        return response;
    }

    /**
     * 知识问答 - 流式输出（增强版，支持会话记忆）
     */
    public SseEmitter knowledgeQAStream(Long userId, String question) {
        log.info("知识问答流式请求 - 用户ID: {}, 问题: {}", userId, question);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.KNOWLEDGE_QA);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildKnowledgePromptWithMemory(question, aiSession);

        // 使用优化的流式输出，60秒超时，按字符分割
        return dashScopeAiUtil.optimizedStreamCall(enhancedPrompt, aiSession.getSessionId(), "word");
    }

    /**
     * 信息查询 - 天气电话资讯（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse informationQuery(Long userId, String query) {
        log.info("信息查询请求 - 用户ID: {}, 查询: {}", userId, query);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.INFORMATION_QUERY);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildInformationQueryPromptWithMemory(query, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), query, response.getText(), null);

        return response;
    }

    /**
     * 信息查询 - 流式输出
     */
    public SseEmitter informationQueryStream(Long userId, String query) {
        log.info("信息查询流式请求 - 用户ID: {}, 查询: {}", userId, query);

        String sessionId = getUserSessionId(userId, "info");
        String enhancedPrompt = "作为一个信息查询助手，请帮助查询以下信息（如果是天气查询，请说明需要具体城市；如果是电话查询，请提供相关建议）：" + query;

        // 使用优化的流式输出，60秒超时，按字符分割
        return dashScopeAiUtil.optimizedStreamCall(enhancedPrompt, sessionId, "word");
    }



    /**
     * 文本生成 - 作文故事诗歌（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse textGeneration(Long userId, String prompt, String type) {
        log.info("文本生成请求 - 用户ID: {}, 类型: {}, 提示: {}", userId, type, prompt);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.TEXT_GENERATION);

        // 设置生成类型到上下文
        aiSessionService.setContextData(aiSession.getSessionId(), "generationType", type);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildTextGenerationPromptWithMemory(prompt, type, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), prompt, response.getText(),
            Map.of("type", type));

        return response;
    }

    /**
     * 文本生成 - 流式输出
     */
    public SseEmitter textGenerationStream(Long userId, String prompt, String type) {
        log.info("文本生成流式请求 - 用户ID: {}, 类型: {}, 提示: {}", userId, type, prompt);

        String sessionId = getUserSessionId(userId, "text_gen");
        String enhancedPrompt = getTextGenerationPrompt(type, prompt);

        return dashScopeAiUtil.streamCall(enhancedPrompt, sessionId);
    }

    /**
     * 语言翻译 - 多语言互译（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse languageTranslation(Long userId, String text, String fromLang, String toLang) {
        log.info("语言翻译请求 - 用户ID: {}, 从{}翻译到{}: {}", userId, fromLang, toLang, text);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.LANGUAGE_TRANSLATION);

        // 设置翻译语言到上下文
        aiSessionService.setContextData(aiSession.getSessionId(), "sourceLanguage", fromLang);
        aiSessionService.setContextData(aiSession.getSessionId(), "targetLanguage", toLang);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildTranslationPromptWithMemory(text, fromLang, toLang, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), text, response.getText(),
            Map.of("fromLang", fromLang, "toLang", toLang));

        return response;
    }

    /**
     * 语言翻译 - 流式输出
     */
    public SseEmitter languageTranslationStream(Long userId, String text, String fromLang, String toLang) {
        log.info("语言翻译流式请求 - 用户ID: {}, 从{}翻译到{}: {}", userId, fromLang, toLang, text);

        String sessionId = getUserSessionId(userId, "translation");
        String enhancedPrompt = String.format("请将以下%s文本翻译成%s：%s", fromLang, toLang, text);

        return dashScopeAiUtil.streamCall(enhancedPrompt, sessionId);
    }

    /**
     * 情感陪伴 - 情感识别回应（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse emotionalCompanion(Long userId, String message) {
        log.info("情感陪伴请求 - 用户ID: {}, 消息: {}", userId, message);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.EMOTIONAL_COMPANION);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildEmotionalCompanionPromptWithMemory(message, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), message, response.getText(), null);

        return response;
    }

    /**
     * 情感陪伴 - 流式输出
     */
    public SseEmitter emotionalCompanionStream(Long userId, String message) {
        log.info("情感陪伴流式请求 - 用户ID: {}, 消息: {}", userId, message);

        String sessionId = getUserSessionId(userId, "emotion");
        String enhancedPrompt = "作为一个温暖贴心的AI伙伴，请识别用户的情感状态并给予适当的回应和安慰。用户说：" + message;

        return dashScopeAiUtil.streamCall(enhancedPrompt, sessionId);
    }

    /**
     * 智能推荐 - 个性化内容（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse intelligentRecommendation(Long userId, String preferences, String category) {
        log.info("智能推荐请求 - 用户ID: {}, 偏好: {}, 类别: {}", userId, preferences, category);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.SMART_RECOMMENDATION);

        // 设置推荐类型到上下文
        aiSessionService.setContextData(aiSession.getSessionId(), "recommendationType", category);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildRecommendationPromptWithMemory(preferences, category, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), preferences, response.getText(),
            Map.of("category", category));

        return response;
    }

    /**
     * 智能推荐 - 流式输出
     */
    public SseEmitter intelligentRecommendationStream(Long userId, String preferences, String category) {
        log.info("智能推荐流式请求 - 用户ID: {}, 偏好: {}, 类别: {}", userId, preferences, category);

        String sessionId = getUserSessionId(userId, "recommendation");
        String enhancedPrompt = String.format("根据用户偏好：%s，请为用户推荐%s相关的个性化内容", preferences, category);

        return dashScopeAiUtil.streamCall(enhancedPrompt, sessionId);
    }

    /**
     * 获取用户会话ID
     */
    private String getUserSessionId(Long userId, String type) {
        Map<String, Object> sessions = userSessions.computeIfAbsent(userId, k -> new ConcurrentHashMap<>());
        return (String) sessions.get(type);
    }

    /**
     * 更新用户会话ID
     */
    private void updateUserSession(Long userId, String type, String sessionId) {
        if (sessionId != null) {
            Map<String, Object> sessions = userSessions.computeIfAbsent(userId, k -> new ConcurrentHashMap<>());
            sessions.put(type, sessionId);
        }
    }

    /**
     * 获取文本生成提示词
     */
    private String getTextGenerationPrompt(String type, String prompt) {
        switch (type.toLowerCase()) {
            case "essay":
            case "作文":
                return "作为一个优秀的作文老师，请根据以下要求写一篇作文：" + prompt;
            case "story":
            case "故事":
                return "作为一个创意故事作家，请根据以下要求创作一个故事：" + prompt;
            case "poem":
            case "诗歌":
                return "作为一个诗人，请根据以下要求创作一首诗歌：" + prompt;
            default:
                return "请根据以下要求进行文本创作：" + prompt;
        }
    }

    /**
     * 清除用户会话
     */
    public void clearUserSessions(Long userId) {
        userSessions.remove(userId);
        log.info("已清除用户{}的所有会话", userId);
    }

    /**
     * 获取用户会话统计
     */
    public Map<String, Object> getUserSessionStats(Long userId) {
        Map<String, Object> sessions = userSessions.get(userId);
        Map<String, Object> stats = new HashMap<>();
        stats.put("userId", userId);
        stats.put("sessionCount", sessions != null ? sessions.size() : 0);
        stats.put("sessionTypes", sessions != null ? sessions.keySet() : Collections.emptySet());
        return stats;
    }

    // ==================== 语音通话相关功能 ====================

    /**
     * 语音通话 - AI智能体对话
     */
    public DashScopeAiUtil.AiResponse voiceChat(Long userId, String message, String agentRole) {
        log.info("语音通话请求 - 用户ID: {}, AI角色: {}, 消息: {}", userId, agentRole, message);

        String sessionId = getUserSessionId(userId, "voice_chat");
        String enhancedPrompt = getVoiceChatPrompt(agentRole, message);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, sessionId);
        updateUserSession(userId, "voice_chat", response.getSessionId());

        return response;
    }

    /**
     * 语音通话 - 流式输出
     */
    public SseEmitter voiceChatStream(Long userId, String message, String agentRole) {
        log.info("语音通话流式请求 - 用户ID: {}, AI角色: {}, 消息: {}", userId, agentRole, message);

        String sessionId = getUserSessionId(userId, "voice_chat");
        String enhancedPrompt = getVoiceChatPrompt(agentRole, message);

        return dashScopeAiUtil.streamCall(enhancedPrompt, sessionId);
    }

    /**
     * 获取语音通话提示词
     */
    private String getVoiceChatPrompt(String agentRole, String message) {
        switch (agentRole.toLowerCase()) {
            case "teacher":
            case "老师":
                return "作为一个专业的AI老师，请耐心回答学生的问题，提供详细的解释和学习建议。学生问：" + message;
            case "friend":
            case "朋友":
                return "作为一个友善的AI朋友，请用轻松愉快的语气与用户聊天，分享有趣的话题。朋友说：" + message;
            case "counselor":
            case "心理师":
                return "作为一个专业的AI心理咨询师，请倾听用户的心声，提供温暖的支持和专业的建议。用户说：" + message;
            case "assistant":
            case "助手":
                return "作为一个全能的AI助手，请高效地帮助用户解决各种问题，提供准确的信息和实用的建议。用户问：" + message;
            default:
                return "作为一个智能AI助手，请回答用户的问题：" + message;
        }
    }

    /**
     * 生成体验Token（当阿里云权限不足时使用）
     */
    public Map<String, Object> generateExperienceToken(String userId, String agentRole) {
        log.info("生成体验Token - 用户ID: {}, AI角色: {}", userId, agentRole);

        Map<String, Object> tokenData = new HashMap<>();
        tokenData.put("token", "eyJSZXF1ZXN0SWQiOiI3NUU1NDVEQi04QTkxLTU5OEYtOEVFNS1EMEE0NEUyNDMxNkMiLCJXb3JrZmxvd1R5cGUiOiJWb2ljZUNoYXQiLCJUZW1wb3JhcnlBSUFnZW50SWQiOiI4OTRhODhiMWVhZmQ0NmVlYWU3OWEwYjU1OWZiMjU2YSIsIkV4cGlyZVRpbWUiOiIyMDI1LTA4LTAzIDAxOjQzOjAzIiwiTmFtZSI6Ijg5NGE4OGIxZWFmZDQ2ZWVhZTc5YTBiNTU5ZmIyNTZhIiwiUmVnaW9uIjoiY24tYmVpamluZyJ9");
        tokenData.put("app_id", "894a88b1eafd46eeae79a0b559fb256a");
        tokenData.put("user_id", userId);
        tokenData.put("timestamp", System.currentTimeMillis());
        tokenData.put("expire_time", "2025-08-03 01:43:03");
        tokenData.put("region", "cn-beijing");
        tokenData.put("agent_role", agentRole);
        tokenData.put("voice_agent_id", "8ed6ed9e6c57469e889a1bc3651ac64b");

        return tokenData;
    }






    /**
     * 游戏娱乐 - 语音游戏互动（增强版）
     */
    public DashScopeAiUtil.AiResponse gameEntertainment(Long userId, String gameType, String userInput, String gameState,
                                                       String difficulty, Integer maxQuestions, Boolean enableHints, Boolean randomMode) {
        log.info("游戏娱乐请求 - 用户ID: {}, 游戏类型: {}, 用户输入: {}, 游戏状态: {}", userId, gameType, userInput, gameState);

        // 获取或创建游戏会话
        GameSession gameSession = gameSessionService.getOrCreateGameSession(userId, gameType);

        // 应用前端传递的配置
        applyGameConfig(gameSession, difficulty, maxQuestions, enableHints, randomMode);

        // 记录开始时间用于计算响应时间
        long startTime = System.currentTimeMillis();

        // 根据游戏状态处理逻辑
        String enhancedPrompt;
        if ("start".equals(gameState) || gameSession.getGameState() == GameSession.GameState.WAITING) {
            // 开始新游戏
            gameSessionService.startGame(gameSession.getSessionId());
            enhancedPrompt = buildGamePrompt(gameType, userInput, "start", gameSession);
        } else {
            // 继续游戏 - 处理用户回答
            enhancedPrompt = buildGamePrompt(gameType, userInput, "playing", gameSession);
        }

        // 使用游戏会话ID作为AI对话会话ID，确保记忆连续性
        String aiSessionId = gameSession.getSessionId();
        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSessionId);
        // 不需要更新会话ID，因为我们使用固定的游戏会话ID

        // 如果是开始游戏，设置当前挑战
        if ("start".equals(gameState)) {
            gameSession.setCurrentChallenge("游戏开始");
            gameSessionService.updateGameSession(gameSession);
        }
        // 如果是回答问题，记录游戏历史
        else if (gameSession.getCurrentChallenge() != null) {
            long responseTime = System.currentTimeMillis() - startTime;
            recordGameAnswer(gameSession, userInput, response.getText(), responseTime);
        }

        return response;
    }

    /**
     * 游戏娱乐 - 流式输出（增强版）
     */
    public SseEmitter gameEntertainmentStream(Long userId, String gameType, String userInput, String gameState,
                                            String difficulty, Integer maxQuestions, Boolean enableHints, Boolean randomMode) {
        log.info("游戏娱乐流式请求 - 用户ID: {}, 游戏类型: {}, 用户输入: {}", userId, gameType, userInput);

        // 获取或创建游戏会话
        GameSession gameSession = gameSessionService.getOrCreateGameSession(userId, gameType);

        // 应用前端传递的配置
        applyGameConfig(gameSession, difficulty, maxQuestions, enableHints, randomMode);

        // 根据游戏状态处理逻辑
        String enhancedPrompt;
        if ("start".equals(gameState) || gameSession.getGameState() == GameSession.GameState.WAITING) {
            // 开始新游戏
            gameSessionService.startGame(gameSession.getSessionId());
            enhancedPrompt = buildGamePrompt(gameType, userInput, "start", gameSession);
        } else {
            // 继续游戏 - 处理用户回答
            enhancedPrompt = buildGamePrompt(gameType, userInput, "playing", gameSession);
        }

        // 使用游戏会话ID作为AI对话会话ID，确保记忆连续性
        String aiSessionId = gameSession.getSessionId();

        // 使用优化的流式输出，60秒超时，按字符分割
        return dashScopeAiUtil.optimizedStreamCall(enhancedPrompt, aiSessionId, "word");
    }



    /**
     * 健康管理 - 健康数据分析和建议（增强版，支持会话记忆）
     */
    public DashScopeAiUtil.AiResponse healthManagement(Long userId, String healthData, String analysisType) {
        log.info("健康管理请求 - 用户ID: {}, 健康数据: {}, 分析类型: {}", userId, healthData, analysisType);

        // 获取或创建AI会话
        AiSession aiSession = aiSessionService.getOrCreateAiSession(userId, AiSession.AiFeatureType.HEALTH_MANAGEMENT);

        // 设置健康关注点到上下文
        aiSessionService.setContextData(aiSession.getSessionId(), "healthFocus", analysisType);

        // 构建包含历史记忆的提示词
        String enhancedPrompt = buildHealthPromptWithMemory(healthData, analysisType, aiSession);

        DashScopeAiUtil.AiResponse response = dashScopeAiUtil.callWithSession(enhancedPrompt, aiSession.getSessionId());

        // 记录对话历史
        aiSessionService.addConversationRecord(aiSession.getSessionId(), healthData, response.getText(),
            Map.of("analysisType", analysisType));

        return response;
    }

    /**
     * 健康管理 - 流式输出
     */
    public SseEmitter healthManagementStream(Long userId, String healthData, String analysisType) {
        log.info("健康管理流式请求 - 用户ID: {}, 健康数据: {}, 分析类型: {}", userId, healthData, analysisType);

        String sessionId = getUserSessionId(userId, "health");
        String enhancedPrompt = buildHealthPrompt(healthData, analysisType);

        // 使用优化的流式输出，60秒超时，按字符分割
        return dashScopeAiUtil.optimizedStreamCall(enhancedPrompt, sessionId, "word");
    }

    /**
     * AI文生图 - 真实图片生成（使用通义万相）
     */
    public DashScopeAiUtil.AiResponse imageGeneration(Long userId, String prompt, String style, String size) {
        log.info("AI文生图请求 - 用户ID: {}, 提示词: {}, 风格: {}, 尺寸: {}", userId, prompt, style, size);

        try {
            // 调用真实的AI图片生成服务
            String imageUrl = generateRealImage(prompt, style, size);

            if (imageUrl != null && !imageUrl.isEmpty()) {
                // 创建成功响应
                DashScopeAiUtil.AiResponse response = new DashScopeAiUtil.AiResponse(
                    imageUrl, // 返回真实生成的图片URL
                    "image_" + System.currentTimeMillis(),
                    true,
                    null
                );

                log.info("AI文生图完成 - 用户ID: {}, 图片URL: {}", userId, imageUrl);
                return response;
            } else {
                log.error("AI文生图失败 - 未能生成有效的图片URL");
                // 返回AI的原始响应，让用户了解失败原因
                String errorMessage = "图片生成失败，请重试";
                if (lastAiResponse != null && !lastAiResponse.trim().isEmpty()) {
                    errorMessage = lastAiResponse;
                }
                return new DashScopeAiUtil.AiResponse(
                    errorMessage, // 将AI响应作为文本内容返回
                    null,
                    false,
                    errorMessage
                );
            }

        } catch (Exception e) {
            log.error("AI文生图异常: {}", e.getMessage(), e);

            String errorMessage = "图片生成异常: " + e.getMessage();
            if (lastAiResponse != null && !lastAiResponse.trim().isEmpty()) {
                errorMessage = lastAiResponse + "\n\n系统异常: " + e.getMessage();
            }

            return new DashScopeAiUtil.AiResponse(
                errorMessage, // 将AI响应和异常信息作为文本内容返回
                null,
                false,
                errorMessage
            );
        }
    }

    /**
     * 调用真实的AI图片生成服务（通义万相）
     */
    private String generateRealImage(String prompt, String style, String size) {
        try {
            log.info("开始调用通义万相图片生成服务，提示词: {}", prompt);

            // 直接调用专门的图片生成方法
            DashScopeAiUtil.AiResponse response = dashScopeAiUtil.generateImage(prompt, style, size);

            if (response.isSuccess() && response.getText() != null) {
                // 从响应中提取图片URL
                String imageUrl = extractImageUrlFromResponse(response.getText());
                if (imageUrl != null && !imageUrl.isEmpty()) {
                    log.info("通义万相生成图片成功: {}", imageUrl);
                    return imageUrl;
                } else {
                    // 如果无法提取URL，直接返回响应文本（可能就是URL）
                    String responseText = response.getText().trim();
                    if (responseText.startsWith("http")) {
                        log.info("直接使用响应文本作为图片URL: {}", responseText);
                        return responseText;
                    } else {
                        // 无法提取URL，但保存AI响应用于错误显示
                        log.warn("无法从AI响应中提取图片URL，保存响应内容用于显示");
                        this.lastAiResponse = responseText;
                        return null;
                    }
                }
            } else {
                // 保存AI的错误响应
                if (response.getText() != null) {
                    this.lastAiResponse = response.getText();
                } else if (response.getErrorMessage() != null) {
                    this.lastAiResponse = response.getErrorMessage();
                }
            }

            log.warn("通义万相未返回有效图片URL，响应: {}", response.getText());
            return null;

        } catch (Exception e) {
            log.error("调用通义万相生成图片失败: {}", e.getMessage(), e);
            this.lastAiResponse = "调用AI服务异常: " + e.getMessage();
            return null;
        }
    }

    /**
     * 构建图片生成提示词
     */
    private String buildImagePrompt(String prompt, String style, String size) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 使用更直接的图片生成提示词格式
        enhancedPrompt.append("请生成一张图片：").append(prompt);

        // 添加风格描述（简化）
        enhancedPrompt.append("风格：");
        switch (style.toLowerCase()) {
            case "realistic":
                enhancedPrompt.append("写实风格");
                break;
            case "cartoon":
                enhancedPrompt.append("卡通风格");
                break;
            case "anime":
                enhancedPrompt.append("动漫风格");
                break;
            case "oil_painting":
                enhancedPrompt.append("油画风格");
                break;
            case "watercolor":
                enhancedPrompt.append("水彩画风格");
                break;
            case "sketch":
                enhancedPrompt.append("素描风格");
                break;
            case "abstract":
                enhancedPrompt.append("抽象风格");
                break;
            case "pixel":
                enhancedPrompt.append("像素风格");
                break;
            default:
                enhancedPrompt.append("写实风格");
        }


        // 添加尺寸
        enhancedPrompt.append("，尺寸：").append(size);

        // 简化结尾
        enhancedPrompt.append("。请生成图片并返回图片URL。");

        return enhancedPrompt.toString();
    }

    /**
     * 从AI响应中提取图片URL
     */
    private String extractImageUrlFromResponse(String responseText) {
        if (responseText == null || responseText.trim().isEmpty()) {
            return null;
        }

        // 首先尝试匹配Markdown格式的图片链接：![](url)
        java.util.regex.Pattern markdownPattern = java.util.regex.Pattern.compile("!\\[.*?\\]\\((https?://[^\\)]+)\\)");
        java.util.regex.Matcher markdownMatcher = markdownPattern.matcher(responseText);
        if (markdownMatcher.find()) {
            String url = markdownMatcher.group(1).trim();
            log.info("从Markdown格式提取到完整图片URL: {}", url);
            return url;
        }

        // 如果没有Markdown格式，尝试匹配各种可能的图片URL格式
        String[] urlPatterns = {
            "https?://dashscope-result[^\\s]+\\.(?:png|jpg|jpeg|gif|webp|bmp)[^\\s]*",
            "https?://[^\\s]+\\.aliyuncs\\.com[^\\s]*\\.(?:png|jpg|jpeg|gif|webp|bmp)[^\\s]*",
            "https?://[^\\s]+\\.(?:png|jpg|jpeg|gif|webp|bmp)[^\\s]*",
            "https?://[^\\s]+"
        };

        for (String pattern : urlPatterns) {
            java.util.regex.Pattern p = java.util.regex.Pattern.compile(pattern, java.util.regex.Pattern.CASE_INSENSITIVE);
            java.util.regex.Matcher m = p.matcher(responseText);
            if (m.find()) {
                String url = m.group().trim();
                // 只移除明显的尾随字符，保留查询参数
                url = url.replaceAll("[)\\]\"'>\\s]+$", "");
                log.info("从响应中提取到图片URL: {}", url);
                return url;
            }
        }

        log.warn("无法从响应中提取图片URL，响应内容: {}", responseText);
        return null;
    }



    /**
     * 构建游戏提示词（增强版）
     */
    private String buildGamePrompt(String gameType, String userInput, String gameState, GameSession gameSession) {
        StringBuilder prompt = new StringBuilder();

        // 添加游戏状态信息
        prompt.append("【游戏状态】\n");
        prompt.append("当前得分: ").append(gameSession.getScore()).append("分\n");
        prompt.append("连胜次数: ").append(gameSession.getWinStreak()).append("次\n");
        prompt.append("游戏等级: ").append(gameSession.getLevel()).append("级\n");
        prompt.append("难度: ").append(gameSession.getGameConfig().getDifficulty()).append("\n");
        if (gameSession.getGameConfig().isEnableHints()) {
            prompt.append("剩余提示次数: ").append(gameSession.getGameConfig().getHintsRemaining()).append("次\n");
        }

        // 添加随机因子，增加内容的多样性
        prompt.append("随机种子: ").append(System.currentTimeMillis() % 1000).append("\n");

        // 添加游戏历史上下文
        if (!gameSession.getGameHistory().isEmpty()) {
            prompt.append("\n【游戏历史】\n");
            int historyCount = Math.min(3, gameSession.getGameHistory().size()); // 只显示最近3轮
            for (int i = gameSession.getGameHistory().size() - historyCount; i < gameSession.getGameHistory().size(); i++) {
                GameSession.GameRecord record = gameSession.getGameHistory().get(i);
                prompt.append("第").append(i + 1).append("轮: ");
                prompt.append("问题「").append(record.getQuestion()).append("」");
                prompt.append(" 用户答案「").append(record.getUserAnswer()).append("」");
                prompt.append(" ").append(record.isCorrect() ? "✓正确" : "✗错误");
                if (record.getPointsEarned() > 0) {
                    prompt.append(" (+").append(record.getPointsEarned()).append("分)");
                }
                prompt.append("\n");
            }
        }
        prompt.append("\n");

        switch (gameType) {
            case "riddle":
                buildRiddlePrompt(prompt, userInput, gameState, gameSession);
                break;
            case "idiom":
                buildIdiomPrompt(prompt, userInput, gameState, gameSession);
                break;
            case "quiz":
                buildQuizPrompt(prompt, userInput, gameState, gameSession);
                break;
            case "story":
                buildStoryPrompt(prompt, userInput, gameState, gameSession);
                break;
            default:
                prompt.append("用户想要玩游戏：").append(userInput).append("。请提供有趣的互动游戏体验。");
        }

        return prompt.toString();
    }

    /**
     * 构建谜语游戏提示词
     */
    private void buildRiddlePrompt(StringBuilder prompt, String userInput, String gameState, GameSession gameSession) {
        prompt.append("【重要】你需要记住我们的游戏进度和历史，保持对话的连续性。\n\n");

        if ("start".equals(gameState)) {
            prompt.append("🎯 欢迎来到谜语挑战！\n");
            prompt.append("你是一个智慧的谜语大师。请根据当前等级(").append(gameSession.getLevel()).append("级)");
            prompt.append("随机出一个适合的谜语。\n");
            prompt.append("谜语要求：\n");
            prompt.append("- 随机选择谜语类型（物品、动物、自然现象、日常用品等）\n");
            prompt.append("- 有趣且有教育意义\n");
            prompt.append("- 难度适中，符合等级\n");
            prompt.append("- 给出明确的谜语内容\n");
            prompt.append("- 每次都要出不同的谜语，保持新鲜感\n");
            prompt.append("请直接出题，不要透露答案。记住这个谜语，以便后续判断用户答案。");
        } else {
            prompt.append("用户的回答是：").append(userInput).append("\n");
            prompt.append("请基于我们之前的对话历史判断答案是否正确：\n");
            prompt.append("- 如果正确：明确说「正确」或「对了」，夸奖用户，说明得分(+").append(gameSession.getGameConfig().getPointsPerCorrect()).append("分)，然后出下一个谜语\n");
            prompt.append("- 如果错误：明确说「错误」或「不对」，给出鼓励和提示，不要直接说出答案\n");
            prompt.append("- 保持游戏的趣味性和挑战性，记住用户的答题历史");
        }
    }

    /**
     * 构建成语接龙提示词
     */
    private void buildIdiomPrompt(StringBuilder prompt, String userInput, String gameState, GameSession gameSession) {
        prompt.append("【重要】你需要记住我们的成语接龙历史，确保接龙的连续性。\n\n");

        if ("start".equals(gameState)) {
            prompt.append("📚 成语接龙挑战开始！\n");
            prompt.append("规则：我说一个成语，你接一个以我的成语最后一个字开头的成语。\n");
            prompt.append("请你随机选择一个适合当前等级的成语作为开始，然后等待我接龙。\n");
            prompt.append("要求：\n");
            prompt.append("- 随机选择开始成语，不要总是用同一个\n");
            prompt.append("- 成语要适合当前等级难度\n");
            prompt.append("- 说出成语后简单解释含义\n");
            prompt.append("- 明确告诉我需要接什么字开头的成语\n");
            prompt.append("记住这个成语序列，保持接龙的连续性。");
        } else {
            prompt.append("用户接的成语是：").append(userInput).append("\n");
            prompt.append("请基于我们之前的成语接龙历史判断：\n");
            prompt.append("- 成语是否正确存在\n");
            prompt.append("- 是否符合接龙规则（首字与上一个成语的尾字相同）\n");
            prompt.append("- 如果正确：明确说「正确」，夸奖并接下一个成语(+").append(gameSession.getGameConfig().getPointsPerCorrect()).append("分)\n");
            prompt.append("- 如果错误：明确说「错误」，指出问题并给出正确示例\n");
            prompt.append("- 记住整个接龙序列，保持游戏连续性");
        }
    }

    /**
     * 构建知识问答提示词
     */
    private void buildQuizPrompt(StringBuilder prompt, String userInput, String gameState, GameSession gameSession) {
        if ("start".equals(gameState)) {
            prompt.append("🧠 知识问答挑战！\n");
            prompt.append("我会出一道选择题，请选择正确答案。\n");
            prompt.append("难度等级：").append(gameSession.getLevel()).append("级\n");
            prompt.append("请随机出一道适合当前等级的选择题（A、B、C、D四个选项）。\n");
            prompt.append("题目要求：\n");
            prompt.append("- 随机选择知识领域（历史、地理、科学、文学、常识等）\n");
            prompt.append("- 题目要有趣且有教育意义\n");
            prompt.append("- 难度符合当前等级\n");
            prompt.append("- 每次出不同类型的题目，保持多样性\n");
            prompt.append("- 四个选项要合理，避免过于明显的错误答案");
        } else {
            prompt.append("用户的答案是：").append(userInput).append("\n");
            prompt.append("请判断答案是否正确：\n");
            prompt.append("- 如果正确：恭喜用户，解释答案，给出得分(+").append(gameSession.getGameConfig().getPointsPerCorrect()).append("分)，然后出下一题\n");
            prompt.append("- 如果错误：说明正确答案和解释，鼓励继续挑战\n");
            prompt.append("- 保持题目的教育性和趣味性");
        }
    }

    /**
     * 构建故事接龙提示词
     */
    private void buildStoryPrompt(StringBuilder prompt, String userInput, String gameState, GameSession gameSession) {
        if ("start".equals(gameState)) {
            prompt.append("📖 创意故事接龙！\n");
            prompt.append("我们一起创作一个有趣的故事。我先开始一个随机的故事开头，你来接续。\n");
            prompt.append("请你随机创作一个故事开头，要求：\n");
            prompt.append("- 随机选择故事背景（现代都市、古代宫廷、未来世界、魔法森林、海底世界等）\n");
            prompt.append("- 随机选择主角（人类、动物、机器人、精灵等）\n");
            prompt.append("- 开头要有趣且引人入胜\n");
            prompt.append("- 为故事设置一个小悬念或冲突\n");
            prompt.append("- 每次都要创作不同的开头，保持新鲜感\n");
            prompt.append("然后等待我来接续故事！");
        } else {
            prompt.append("用户接续的故事：").append(userInput).append("\n");
            prompt.append("很棒的创意！现在请你继续这个故事：\n");
            prompt.append("- 让情节更加有趣和富有想象力\n");
            prompt.append("- 保持故事的连贯性\n");
            prompt.append("- 给用户创意加分(+").append(gameSession.getGameConfig().getPointsPerCorrect()).append("分)\n");
            prompt.append("- 然后继续推进故事情节");
        }
    }

    /**
     * 记录游戏答题结果
     */
    private void recordGameAnswer(GameSession gameSession, String userAnswer, String aiResponse, long responseTime) {
        // 更智能的正确性判断逻辑
        boolean isCorrect = isAnswerCorrect(aiResponse);

        String question = gameSession.getCurrentChallenge();
        if (question == null) {
            question = "第" + (gameSession.getGameHistory().size() + 1) + "题";
        }

        // 记录到游戏会话中
        gameSessionService.recordAnswer(
            gameSession.getSessionId(),
            question,
            userAnswer,
            extractCorrectAnswer(aiResponse), // 尝试从AI响应中提取正确答案
            isCorrect,
            responseTime
        );

        // 更新当前挑战为下一题
        gameSession.setCurrentChallenge("第" + (gameSession.getGameHistory().size() + 1) + "题");
        gameSessionService.updateGameSession(gameSession);

        log.info("记录游戏答题: sessionId={}, 用户答案={}, 是否正确={}, 响应时间={}ms",
                gameSession.getSessionId(), userAnswer, isCorrect, responseTime);
    }

    /**
     * 判断答案是否正确
     */
    private boolean isAnswerCorrect(String aiResponse) {
        String response = aiResponse.toLowerCase();

        // 正确的关键词
        String[] correctKeywords = {"正确", "对了", "很好", "恭喜", "答对", "正确答案", "回答正确",
                                   "太棒了", "excellent", "correct", "right", "好的", "不错"};

        // 错误的关键词
        String[] incorrectKeywords = {"错误", "不对", "错了", "不正确", "再想想", "提示", "incorrect",
                                     "wrong", "try again", "重新", "不是"};

        // 先检查错误关键词，如果包含错误关键词则认为错误
        for (String keyword : incorrectKeywords) {
            if (response.contains(keyword)) {
                return false;
            }
        }

        // 再检查正确关键词
        for (String keyword : correctKeywords) {
            if (response.contains(keyword)) {
                return true;
            }
        }

        // 如果都没有匹配，默认认为是正确的（继续游戏）
        return true;
    }

    /**
     * 从AI响应中提取正确答案
     */
    private String extractCorrectAnswer(String aiResponse) {
        // 简单的正确答案提取逻辑
        if (aiResponse.contains("正确答案是") || aiResponse.contains("答案是")) {
            String[] parts = aiResponse.split("答案是");
            if (parts.length > 1) {
                String answer = parts[1].trim();
                // 提取第一句话作为答案
                int endIndex = Math.min(answer.indexOf("。"), answer.indexOf("\n"));
                if (endIndex > 0) {
                    return answer.substring(0, endIndex).trim();
                }
                return answer.length() > 20 ? answer.substring(0, 20) + "..." : answer;
            }
        }
        return ""; // 无法提取时返回空字符串
    }

    /**
     * 应用前端传递的游戏配置
     */
    private void applyGameConfig(GameSession gameSession, String difficulty, Integer maxQuestions, Boolean enableHints, Boolean randomMode) {
        GameSession.GameConfig config = gameSession.getGameConfig();

        // 应用难度设置
        if (difficulty != null && !difficulty.isEmpty()) {
            config.setDifficulty(difficulty);
            // 根据难度调整分数倍数
            switch (difficulty) {
                case "easy":
                    config.setBonusMultiplier(1);
                    break;
                case "normal":
                    config.setBonusMultiplier(2);
                    break;
                case "hard":
                    config.setBonusMultiplier(3);
                    break;
            }
        }

        // 应用最大题数设置
        if (maxQuestions != null && maxQuestions > 0) {
            config.setMaxQuestions(maxQuestions);
        }

        // 应用提示设置
        if (enableHints != null) {
            config.setEnableHints(enableHints);
            if (!enableHints) {
                config.setHintsRemaining(0);
            }
        }

        // 应用随机模式设置（存储在会话中，用于提示词生成）
        if (randomMode != null) {
            // 可以在GameSession中添加randomMode字段，这里暂时通过其他方式处理
            log.debug("随机模式: {}", randomMode ? "开启" : "关闭");
        }

        // 更新会话
        gameSessionService.updateGameSession(gameSession);

        log.debug("应用游戏配置: sessionId={}, difficulty={}, maxQuestions={}, enableHints={}, randomMode={}",
                 gameSession.getSessionId(), difficulty, maxQuestions, enableHints, randomMode);
    }



    /**
     * 构建知识问答提示词（包含会话记忆）
     */
    private String buildKnowledgePromptWithMemory(String question, AiSession aiSession) {
        StringBuilder prompt = new StringBuilder();

        // 添加会话上下文
        prompt.append("【会话信息】\n");
        prompt.append("功能类型: 知识问答\n");
        prompt.append("交互次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");
        prompt.append("用户偏好: ").append(aiSession.getUserPreferences().getResponseStyle()).append("风格\n");

        // 添加历史对话上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            prompt.append("\n【对话历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(3);
            for (int i = 0; i < recentHistory.size(); i++) {
                AiSession.ConversationRecord record = recentHistory.get(i);
                prompt.append("Q").append(i + 1).append(": ").append(record.getUserInput()).append("\n");
                prompt.append("A").append(i + 1).append(": ").append(record.getAiResponse().substring(0, Math.min(100, record.getAiResponse().length()))).append("...\n");
            }
        }

        prompt.append("\n【当前任务】\n");
        prompt.append("作为一个知识渊博的AI助手，请基于以上对话历史，详细回答以下问题：\n");
        prompt.append(question);
        prompt.append("\n\n要求：\n");
        prompt.append("- 如果与之前的问题相关，请结合历史对话提供连贯的回答\n");
        prompt.append("- 保持").append(aiSession.getUserPreferences().getResponseStyle()).append("的回复风格\n");
        prompt.append("- 提供准确、详细的信息");

        return prompt.toString();
    }

    /**
     * 构建信息查询提示词（包含会话记忆）
     */
    private String buildInformationQueryPromptWithMemory(String query, AiSession aiSession) {
        StringBuilder prompt = new StringBuilder();

        // 添加会话上下文
        prompt.append("【会话信息】\n");
        prompt.append("功能类型: 信息查询\n");
        prompt.append("交互次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");
        prompt.append("查询范围: ").append(aiSession.getContextValue("searchScope")).append("\n");

        // 添加历史查询上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            prompt.append("\n【查询历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(3);
            for (AiSession.ConversationRecord record : recentHistory) {
                prompt.append("历史查询: ").append(record.getUserInput()).append("\n");
            }
        }

        prompt.append("\n【当前查询】\n");
        prompt.append("作为一个信息查询助手，请帮助查询以下信息：\n");
        prompt.append(query);
        prompt.append("\n\n要求：\n");
        prompt.append("- 如果与历史查询相关，请提供关联信息\n");
        prompt.append("- 如果是天气查询，请说明需要具体城市\n");
        prompt.append("- 如果是电话查询，请提供相关建议\n");
        prompt.append("- 提供准确、实用的信息");

        return prompt.toString();
    }

    /**
     * 构建健康提示词
     */
    private String buildHealthPrompt(String healthData, String analysisType) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("作为一个专业的健康管理顾问，请分析以下健康数据并提供建议：\n");
        prompt.append("健康数据：").append(healthData).append("\n");
        prompt.append("分析类型：").append(analysisType).append("\n");
        prompt.append("请提供：\n");
        prompt.append("1. 健康状况评估\n");
        prompt.append("2. 具体的改善建议\n");
        prompt.append("3. 日常生活指导\n");
        prompt.append("4. 注意事项\n");
        prompt.append("建议要实用、具体，适合学生群体。");

        return prompt.toString();
    }

    /**
     * 构建文本生成提示词（包含会话记忆）
     */
    private String buildTextGenerationPromptWithMemory(String prompt, String type, AiSession aiSession) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 添加会话上下文
        enhancedPrompt.append("【会话信息】\n");
        enhancedPrompt.append("功能类型: 文本生成\n");
        enhancedPrompt.append("生成类型: ").append(type).append("\n");
        enhancedPrompt.append("交互次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");

        // 添加历史生成上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            enhancedPrompt.append("\n【生成历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(2);
            for (AiSession.ConversationRecord record : recentHistory) {
                enhancedPrompt.append("历史需求: ").append(record.getUserInput()).append("\n");
                enhancedPrompt.append("生成风格: ").append(record.getMetadata().get("type")).append("\n");
            }
        }

        enhancedPrompt.append("\n【当前任务】\n");
        enhancedPrompt.append(getTextGenerationPrompt(type, prompt));
        enhancedPrompt.append("\n\n要求：\n");
        enhancedPrompt.append("- 保持").append(aiSession.getUserPreferences().getResponseStyle()).append("的创作风格\n");
        enhancedPrompt.append("- 如果与历史生成内容相关，请保持连贯性\n");
        enhancedPrompt.append("- 确保内容原创且高质量");

        return enhancedPrompt.toString();
    }

    /**
     * 构建翻译提示词（包含会话记忆）
     */
    private String buildTranslationPromptWithMemory(String text, String fromLang, String toLang, AiSession aiSession) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 添加会话上下文
        enhancedPrompt.append("【翻译会话信息】\n");
        enhancedPrompt.append("源语言: ").append(fromLang).append("\n");
        enhancedPrompt.append("目标语言: ").append(toLang).append("\n");
        enhancedPrompt.append("翻译次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");

        // 添加翻译历史上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            enhancedPrompt.append("\n【翻译历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(2);
            for (AiSession.ConversationRecord record : recentHistory) {
                enhancedPrompt.append("原文: ").append(record.getUserInput()).append("\n");
                enhancedPrompt.append("译文: ").append(record.getAiResponse().substring(0, Math.min(50, record.getAiResponse().length()))).append("...\n");
            }
        }

        enhancedPrompt.append("\n【当前翻译任务】\n");
        enhancedPrompt.append("请将以下").append(fromLang).append("文本翻译成").append(toLang).append("：\n");
        enhancedPrompt.append(text);
        enhancedPrompt.append("\n\n要求：\n");
        enhancedPrompt.append("- 保持翻译的准确性和流畅性\n");
        enhancedPrompt.append("- 如果与之前翻译内容相关，请保持术语一致性\n");
        enhancedPrompt.append("- 只返回翻译结果");

        return enhancedPrompt.toString();
    }

    /**
     * 构建情感陪伴提示词（包含会话记忆）
     */
    private String buildEmotionalCompanionPromptWithMemory(String message, AiSession aiSession) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 添加会话上下文
        enhancedPrompt.append("【陪伴会话信息】\n");
        enhancedPrompt.append("陪伴模式: ").append(aiSession.getContextValue("companionMode")).append("\n");
        enhancedPrompt.append("交流次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");

        // 添加情感历史上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            enhancedPrompt.append("\n【情感交流历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(3);
            for (AiSession.ConversationRecord record : recentHistory) {
                enhancedPrompt.append("用户: ").append(record.getUserInput()).append("\n");
                enhancedPrompt.append("情感: ").append(record.getSentiment() != null ? record.getSentiment() : "未知").append("\n");
            }
        }

        enhancedPrompt.append("\n【当前情感交流】\n");
        enhancedPrompt.append("作为一个温暖贴心的AI伙伴，请基于以上交流历史，识别用户的情感状态并给予适当的回应和安慰。\n");
        enhancedPrompt.append("用户说：").append(message);
        enhancedPrompt.append("\n\n要求：\n");
        enhancedPrompt.append("- 结合历史交流，提供连贯的情感支持\n");
        enhancedPrompt.append("- 保持").append(aiSession.getUserPreferences().getResponseStyle()).append("的交流风格\n");
        enhancedPrompt.append("- 给予真诚的关怀和建议");

        return enhancedPrompt.toString();
    }

    /**
     * 构建智能推荐提示词（包含会话记忆）
     */
    private String buildRecommendationPromptWithMemory(String preferences, String category, AiSession aiSession) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 添加会话上下文
        enhancedPrompt.append("【推荐会话信息】\n");
        enhancedPrompt.append("推荐类型: ").append(category).append("\n");
        enhancedPrompt.append("推荐次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");

        // 添加推荐历史上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            enhancedPrompt.append("\n【推荐历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(3);
            for (AiSession.ConversationRecord record : recentHistory) {
                enhancedPrompt.append("历史偏好: ").append(record.getUserInput()).append("\n");
                enhancedPrompt.append("推荐类别: ").append(record.getMetadata().get("category")).append("\n");
            }
        }

        enhancedPrompt.append("\n【当前推荐任务】\n");
        enhancedPrompt.append("根据用户偏好：").append(preferences).append("\n");
        enhancedPrompt.append("请为用户推荐").append(category).append("相关的个性化内容");
        enhancedPrompt.append("\n\n要求：\n");
        enhancedPrompt.append("- 结合历史偏好，提供个性化推荐\n");
        enhancedPrompt.append("- 避免重复之前的推荐内容\n");
        enhancedPrompt.append("- 包括具体的推荐理由\n");
        enhancedPrompt.append("- 保持").append(aiSession.getUserPreferences().getResponseStyle()).append("的推荐风格");

        return enhancedPrompt.toString();
    }

    /**
     * 构建健康管理提示词（包含会话记忆）
     */
    private String buildHealthPromptWithMemory(String healthData, String analysisType, AiSession aiSession) {
        StringBuilder enhancedPrompt = new StringBuilder();

        // 添加会话上下文
        enhancedPrompt.append("【健康管理会话信息】\n");
        enhancedPrompt.append("关注重点: ").append(aiSession.getContextValue("healthFocus")).append("\n");
        enhancedPrompt.append("咨询次数: ").append(aiSession.getSessionStats().getTotalInteractions()).append("次\n");

        // 添加健康历史上下文
        if (!aiSession.getConversationHistory().isEmpty()) {
            enhancedPrompt.append("\n【健康记录历史】\n");
            List<AiSession.ConversationRecord> recentHistory = aiSession.getRecentHistory(3);
            for (AiSession.ConversationRecord record : recentHistory) {
                enhancedPrompt.append("历史数据: ").append(record.getUserInput().substring(0, Math.min(50, record.getUserInput().length()))).append("...\n");
                enhancedPrompt.append("分析类型: ").append(record.getMetadata().get("analysisType")).append("\n");
            }
        }

        enhancedPrompt.append("\n【当前健康分析】\n");
        enhancedPrompt.append(buildHealthPrompt(healthData, analysisType));
        enhancedPrompt.append("\n\n要求：\n");
        enhancedPrompt.append("- 结合历史健康数据，提供连续性的健康建议\n");
        enhancedPrompt.append("- 保持").append(aiSession.getUserPreferences().getResponseStyle()).append("的咨询风格\n");
        enhancedPrompt.append("- 注意健康数据的变化趋势\n");
        enhancedPrompt.append("- 提供个性化的改善方案");

        return enhancedPrompt.toString();
    }
}
